{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"softmax.ipynb","provenance":[],"collapsed_sections":[],"toc_visible":true},"kernelspec":{"name":"python3","display_name":"Python 3"}},"cells":[{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Wn23ESPrECJL","executionInfo":{"status":"ok","timestamp":1611324210339,"user_tz":-60,"elapsed":25117,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"48f13ec0-6c25-4ce7-8090-693b62df3062"},"source":["from google.colab import drive\n","\n","drive.mount('/content/drive', force_remount=True)\n","\n","# enter the foldername in your Drive where you have saved the unzipped\n","# 'cs231n' folder containing the '.py', 'classifiers' and 'datasets'\n","# folders.\n","# e.g. 'cs231n/assignments/assignment1/cs231n/'\n","FOLDERNAME = 'cs231n/assignments/assignment1/cs231n/'\n","\n","assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n","\n","%cd drive/My\\ Drive\n","%cp -r $FOLDERNAME ../../\n","%cd ../../\n","%cd cs231n/datasets/\n","!bash get_datasets.sh\n","%cd ../../"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Mounted at /content/drive\n","/content/drive/My Drive\n","/content\n","/content/cs231n/datasets\n","--2021-01-22 14:03:23--  http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n","Resolving www.cs.toronto.edu (www.cs.toronto.edu)... 128.100.3.30\n","Connecting to www.cs.toronto.edu (www.cs.toronto.edu)|128.100.3.30|:80... connected.\n","HTTP request sent, awaiting response... 200 OK\n","Length: 170498071 (163M) [application/x-gzip]\n","Saving to: ‘cifar-10-python.tar.gz’\n","\n","cifar-10-python.tar 100%[===================>] 162.60M  69.1MB/s    in 2.4s    \n","\n","2021-01-22 14:03:25 (69.1 MB/s) - ‘cifar-10-python.tar.gz’ saved [170498071/170498071]\n","\n","cifar-10-batches-py/\n","cifar-10-batches-py/data_batch_4\n","cifar-10-batches-py/readme.html\n","cifar-10-batches-py/test_batch\n","cifar-10-batches-py/data_batch_3\n","cifar-10-batches-py/batches.meta\n","cifar-10-batches-py/data_batch_2\n","cifar-10-batches-py/data_batch_5\n","cifar-10-batches-py/data_batch_1\n","/content\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-title"],"id":"EeM4R9xBECJT"},"source":["# Softmax exercise\n","\n","*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n","\n","This exercise is analogous to the SVM exercise. You will:\n","\n","- implement a fully-vectorized **loss function** for the Softmax classifier\n","- implement the fully-vectorized expression for its **analytic gradient**\n","- **check your implementation** with numerical gradient\n","- use a validation set to **tune the learning rate and regularization** strength\n","- **optimize** the loss function with **SGD**\n","- **visualize** the final learned weights\n"]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"id":"SK6UB4Q_ECJU"},"source":["import random\n","import numpy as np\n","from cs231n.data_utils import load_CIFAR10\n","import matplotlib.pyplot as plt\n","\n","%matplotlib inline\n","plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n","plt.rcParams['image.interpolation'] = 'nearest'\n","plt.rcParams['image.cmap'] = 'gray'\n","\n","# for auto-reloading extenrnal modules\n","# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n","%load_ext autoreload\n","%autoreload 2"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"qTgSBas-ECJU","executionInfo":{"status":"ok","timestamp":1611324274582,"user_tz":-60,"elapsed":4146,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"cfa0fc95-c2f3-434d-fce4-5a387a6a129a"},"source":["def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n","    \"\"\"\n","    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n","    it for the linear classifier. These are the same steps as we used for the\n","    SVM, but condensed to a single function.  \n","    \"\"\"\n","    # Load the raw CIFAR-10 data\n","    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n","    \n","    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n","    try:\n","       del X_train, y_train\n","       del X_test, y_test\n","       print('Clear previously loaded data.')\n","    except:\n","       pass\n","\n","    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n","    \n","    # subsample the data\n","    mask = list(range(num_training, num_training + num_validation))\n","    X_val = X_train[mask]\n","    y_val = y_train[mask]\n","    mask = list(range(num_training))\n","    X_train = X_train[mask]\n","    y_train = y_train[mask]\n","    mask = list(range(num_test))\n","    X_test = X_test[mask]\n","    y_test = y_test[mask]\n","    mask = np.random.choice(num_training, num_dev, replace=False)\n","    X_dev = X_train[mask]\n","    y_dev = y_train[mask]\n","    \n","    # Preprocessing: reshape the image data into rows\n","    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n","    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n","    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n","    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n","    \n","    # Normalize the data: subtract the mean image\n","    mean_image = np.mean(X_train, axis = 0)\n","    X_train -= mean_image\n","    X_val -= mean_image\n","    X_test -= mean_image\n","    X_dev -= mean_image\n","    \n","    # add bias dimension and transform into columns\n","    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n","    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n","    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n","    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n","    \n","    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n","\n","\n","# Invoke the above function to get our data.\n","X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n","print('Train data shape: ', X_train.shape)\n","print('Train labels shape: ', y_train.shape)\n","print('Validation data shape: ', X_val.shape)\n","print('Validation labels shape: ', y_val.shape)\n","print('Test data shape: ', X_test.shape)\n","print('Test labels shape: ', y_test.shape)\n","print('dev data shape: ', X_dev.shape)\n","print('dev labels shape: ', y_dev.shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Train data shape:  (49000, 3073)\n","Train labels shape:  (49000,)\n","Validation data shape:  (1000, 3073)\n","Validation labels shape:  (1000,)\n","Test data shape:  (1000, 3073)\n","Test labels shape:  (1000,)\n","dev data shape:  (500, 3073)\n","dev labels shape:  (500,)\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"B9XBkJ3YECJW"},"source":["## Softmax Classifier\n","\n","Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LDy4xf2DECJW","executionInfo":{"status":"ok","timestamp":1611324441565,"user_tz":-60,"elapsed":1118,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"98e1c28a-76d5-47aa-f94d-33ac15ba2810"},"source":["# First implement the naive softmax loss function with nested loops.\n","# Open the file cs231n/classifiers/softmax.py and implement the\n","# softmax_loss_naive function.\n","\n","from cs231n.classifiers.softmax import softmax_loss_naive\n","import time\n","\n","# Generate a random softmax weight matrix and use it to compute the loss.\n","W = np.random.randn(3073, 10) * 0.0001\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n","\n","# As a rough sanity check, our loss should be something close to -log(0.1).\n","print('loss: %f' % loss)\n","print('sanity check: %f' % (-np.log(0.1)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["loss: 2.322750\n","sanity check: 2.302585\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"vLgazbi1ECJX"},"source":["**Inline Question 1**\n","\n","Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n","\n","$\\color{blue}{\\textit Your Answer:}$ In the data preprocessing, **X_dev** is normalized (*mean* ≈ 0, *std* ≈ 1). So, the multiplication between **X_dev** and **W** will result in a matrix with values (*val*) relatively close to each other. With the number of classes $C=10$, we'll get: $\\frac{e^{val}}{C * e^{val}} = \\frac{e^{val}}{10 * e^{val}} ≈ 0.1$ [Denominator values are close to each other, so we can directly multiply by $C$, instead of summing them] (for every single **X_dev** sample, which will be divided by N, so, the final result will be also close to **0.1**). And by applying the softmax loss function, we'll get: **-log(0.1)**."]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"w8v0xlyTECJX","executionInfo":{"status":"ok","timestamp":1611324450104,"user_tz":-60,"elapsed":6411,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"8e5ea4bc-db58-447c-df35-4468e7b8afa6"},"source":["# Complete the implementation of softmax_loss_naive and implement a (naive)\n","# version of the gradient that uses nested loops.\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n","\n","# As we did for the SVM, use numeric gradient checking as a debugging tool.\n","# The numeric gradient should be close to the analytic gradient.\n","from cs231n.gradient_check import grad_check_sparse\n","f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n","grad_numerical = grad_check_sparse(f, W, grad, 10)\n","\n","# similar to SVM case, do another gradient check with regularization\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n","f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n","grad_numerical = grad_check_sparse(f, W, grad, 10)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["numerical: -2.405989 analytic: -2.405989, relative error: 8.762001e-09\n","numerical: -1.554251 analytic: -1.554251, relative error: 5.237692e-08\n","numerical: 0.098306 analytic: 0.098306, relative error: 3.893297e-07\n","numerical: 0.097479 analytic: 0.097479, relative error: 5.392960e-08\n","numerical: -0.207212 analytic: -0.207212, relative error: 1.097736e-07\n","numerical: -0.029221 analytic: -0.029221, relative error: 3.005833e-06\n","numerical: 1.595536 analytic: 1.595536, relative error: 2.211457e-08\n","numerical: -1.093525 analytic: -1.093525, relative error: 2.311254e-08\n","numerical: 0.757587 analytic: 0.757587, relative error: 5.062852e-08\n","numerical: -1.507960 analytic: -1.507960, relative error: 1.564765e-08\n","numerical: -0.487731 analytic: -0.487731, relative error: 9.720138e-08\n","numerical: -1.770322 analytic: -1.770322, relative error: 4.287101e-08\n","numerical: 2.332688 analytic: 2.332688, relative error: 9.362696e-09\n","numerical: 2.570502 analytic: 2.570502, relative error: 4.806156e-09\n","numerical: -5.324541 analytic: -5.324542, relative error: 8.506626e-09\n","numerical: 0.306370 analytic: 0.306370, relative error: 2.915036e-07\n","numerical: -2.795721 analytic: -2.795721, relative error: 2.812300e-08\n","numerical: -0.589289 analytic: -0.589289, relative error: 1.039900e-08\n","numerical: 0.069590 analytic: 0.069590, relative error: 6.788522e-07\n","numerical: 2.587821 analytic: 2.587821, relative error: 1.049984e-08\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ZEhAB4ynECJX","executionInfo":{"status":"ok","timestamp":1611324455899,"user_tz":-60,"elapsed":680,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"c332108f-542d-4d1a-b54b-45781bf9a45b"},"source":["# Now that we have a naive implementation of the softmax loss function and its gradient,\n","# implement a vectorized version in softmax_loss_vectorized.\n","# The two versions should compute the same results, but the vectorized version should be\n","# much faster.\n","tic = time.time()\n","loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n","toc = time.time()\n","print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n","\n","from cs231n.classifiers.softmax import softmax_loss_vectorized\n","tic = time.time()\n","loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n","toc = time.time()\n","print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n","\n","# As we did for the SVM, we use the Frobenius norm to compare the two versions\n","# of the gradient.\n","grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n","print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n","print('Gradient difference: %f' % grad_difference)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["naive loss: 2.322750e+00 computed in 0.138603s\n","vectorized loss: 2.322750e+00 computed in 0.018519s\n","Loss difference: 0.000000\n","Gradient difference: 0.000000\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"tuning","tags":["code"],"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1611324551242,"user_tz":-60,"elapsed":11516,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"40f0f1ab-0242-498a-b884-5f9ab9e7e9da"},"source":["# Use the validation set to tune hyperparameters (regularization strength and\n","# learning rate). You should experiment with different ranges for the learning\n","# rates and regularization strengths; if you are careful you should be able to\n","# get a classification accuracy of over 0.35 on the validation set.\n","\n","from cs231n.classifiers import Softmax\n","results = {}\n","best_val = -1\n","best_softmax = None\n","\n","################################################################################\n","# TODO:                                                                        #\n","# Use the validation set to set the learning rate and regularization strength. #\n","# This should be identical to the validation that you did for the SVM; save    #\n","# the best trained softmax classifer in best_softmax.                          #\n","################################################################################\n","\n","# Provided as a reference. You may or may not want to change these hyperparameters\n","learning_rates = [1e-6] # Modified\n","regularization_strengths = [5e3] # Modified\n","\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","for lr in learning_rates:\n","  for rs in regularization_strengths:\n","    softmax = Softmax()\n","    loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=rs,\n","                          num_iters=1500, verbose=False)\n","\n","    y_train_pred = softmax.predict(X_train)\n","    training_accuracy = np.mean(y_train == y_train_pred)\n","\n","    y_val_pred = softmax.predict(X_val)\n","    validation_accuracy = np.mean(y_val == y_val_pred)\n","\n","    results[(lr, rs)] = (training_accuracy, validation_accuracy)\n","\n","    if validation_accuracy > best_val:\n","      best_val = validation_accuracy\n","      best_softmax = softmax\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","    \n","# Print out results.\n","for lr, reg in sorted(results):\n","    train_accuracy, val_accuracy = results[(lr, reg)]\n","    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n","                lr, reg, train_accuracy, val_accuracy))\n","    \n","print('best validation accuracy achieved during cross-validation: %f' % best_val)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["lr 1.000000e-06 reg 5.000000e+03 train accuracy: 0.374163 val accuracy: 0.385000\n","best validation accuracy achieved during cross-validation: 0.385000\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"test","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1611324558556,"user_tz":-60,"elapsed":753,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"21694e4c-d67c-4091-886c-b4d2983018bb"},"source":["# evaluate on test set\n","# Evaluate the best softmax on test set\n","y_test_pred = best_softmax.predict(X_test)\n","test_accuracy = np.mean(y_test == y_test_pred)\n","print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["softmax on raw pixels final test set accuracy: 0.373000\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"ipzFgSK-ECJZ"},"source":["**Inline Question 2** - *True or False*\n","\n","Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n","\n","$\\color{blue}{\\textit Your Answer:}$ No, it is not possible to add a new datapoint to a training set that would leave the “new” SVM loss unchanged.\n","\n","$\\color{blue}{\\textit Your Explanation:}$ The new loss formula, as defined in the question, will be:\n","\n","$\\sum_{i=0}^{N}-log(\\frac{e^{y_{i, correct}}}{\\sum_{j=0}^{C}e^{y_{i, j}}})$ , with *N: Size of the training set* and *C: Number of classes*.\n","\n","To leave the SVM loss unchanged, the new datapoint must have a null loss, therefore, the inner value of the log function have to be equals to 1 (so, **log(1) = 0**). And the latter is not possible to achieve, because the fraction (inside the log function) result value is bounded by 0 and 1 (strictly, in both sides)."]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":380},"id":"0Cave-V9ECJZ","executionInfo":{"status":"ok","timestamp":1611324709723,"user_tz":-60,"elapsed":1447,"user":{"displayName":"Soufian Benamara","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj7-UwGIuLvBwNdi62Q2pMRjoHrgtEm3LZkyGEWZw=s64","userId":"08596286217915945464"}},"outputId":"b3c3760a-221b-47e4-d554-eb7b2487a408"},"source":["# Visualize the learned weights for each class\n","w = best_softmax.W[:-1,:] # strip out the bias\n","w = w.reshape(32, 32, 3, 10)\n","\n","w_min, w_max = np.min(w), np.max(w)\n","\n","classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n","for i in range(10):\n","    plt.subplot(2, 5, i + 1)\n","    \n","    # Rescale the weights to be between 0 and 255\n","    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n","    plt.imshow(wimg.astype('uint8'))\n","    plt.axis('off')\n","    plt.title(classes[i])"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x576 with 10 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"UXKOoMXKECJa"},"source":["---\n","# IMPORTANT\n","\n","This is the end of this question. Please do the following:\n","\n","1. Click `File -> Save` to make sure the latest checkpoint of this notebook is saved to your Drive.\n","2. Execute the cell below to download the modified `.py` files back to your drive."]},{"cell_type":"code","metadata":{"id":"LPLFhnQoECJa"},"source":["import os\n","\n","FOLDER_TO_SAVE = os.path.join('drive/My Drive/', FOLDERNAME)\n","FILES_TO_SAVE = ['cs231n/classifiers/softmax.py']\n","\n","for files in FILES_TO_SAVE:\n","  with open(os.path.join(FOLDER_TO_SAVE, '/'.join(files.split('/')[1:])), 'w') as f:\n","    f.write(''.join(open(files).readlines()))"],"execution_count":null,"outputs":[]}]}